home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1999 / MacHack 1999.toast / The Hacks / DesktopDoubler / NubApp / Menu.cc < prev    next >
Text File  |  1999-06-23  |  6KB  |  482 lines
  1. #define DISABLE_LOCAL_CALLTRACE        1        // Set to 1 to disable Call Traces for this file.
  2. #define DISABLE_LOCAL_DEBUG            0        // Set to 1 to disable all debugging for this file.
  3. #include "DebugUtils.h"
  4.  
  5. #include <ctype.h>
  6. #include <Devices.h>
  7. #include <string.h>
  8. #include "Main.h"
  9. #include "Menu.h"
  10. #include "Notice.h"
  11. #include "QDUtils.h"
  12. #include "StringUtils.h"
  13. #include "Version.h"
  14. #include "Window.h"
  15.  
  16.  
  17.  
  18.  
  19.  
  20. extern WindowManager                *gWindowManager;
  21. extern MenuManager                    *gMenuManager;
  22.  
  23.  
  24.  
  25.  
  26.  
  27. void BaseMenuManager::DoAddMenu(Menu *menu)
  28. {
  29.     HandleAddMenu(menu);
  30. }
  31.  
  32.  
  33.  
  34.  
  35.  
  36. void BaseMenuManager::DoMenuUpdates(void)
  37. {
  38.     BaseMenuObject    *mobj;
  39.     Window            *win;
  40.     Boolean            redraw;
  41.     
  42.     
  43.     mobj = fMenuList.GetFirst();
  44.     while(mobj != NULL)
  45.     {
  46.         HandleMenuUpdate(mobj->fMenuObject);
  47.         mobj = mobj->next;
  48.     }
  49.     
  50.     redraw = false;
  51.     win = gWindowManager->DoGetFrontWindow();
  52.     if (win && ((win->fFlags & (kDialog | kModal)) == (kDialog | kModal)))
  53.     {
  54.         // Enable Moveable Modal Dialog state
  55.         mobj = fMenuList.GetFirst();
  56.         while(mobj != NULL)
  57.         {
  58.             if (mobj->fMenuObject->DoSetDisableState(true))
  59.                 redraw = true;
  60.             
  61.             mobj = mobj->next;
  62.         }
  63.     }
  64.     else
  65.     {
  66.         // Disable Moveable Modal Dialog state
  67.         mobj = fMenuList.GetFirst();
  68.         while(mobj != NULL)
  69.         {
  70.             if (mobj->fMenuObject->DoSetDisableState(false))
  71.                 redraw = true;
  72.             
  73.             mobj = mobj->next;
  74.         }
  75.     }
  76.     
  77.     if (redraw)
  78.         ::DrawMenuBar();
  79. }
  80.  
  81.  
  82.  
  83.  
  84.  
  85. void BaseMenuManager::DoSelect(UInt32 menu,UInt32 item)
  86. {
  87.     Menu    *mobj;
  88.     
  89.     
  90.     mobj = DoGetMenu(menu);
  91.     if (mobj != NULL)
  92.         HandleSelect(mobj,item);
  93.     
  94.     ::HiliteMenu(0);
  95. }
  96.  
  97.  
  98.  
  99.  
  100.  
  101. void BaseMenuManager::DoWindowNotice(Window *window,Boolean isBeingAdded)
  102. {
  103.     BaseMenuObject    *mobj;
  104.     
  105.     
  106.     mobj = fMenuList.GetFirst();
  107.     while(mobj != NULL)
  108.     {
  109.         HandleWindowNotice(mobj->fMenuObject,window,isBeingAdded);
  110.         mobj = mobj->next;
  111.     }
  112. }
  113.  
  114.  
  115.  
  116.  
  117.  
  118. void BaseMenuManager::DoWindowActivation(Window *window,Boolean isBeingActivated)
  119. {
  120.     BaseMenuObject    *mobj;
  121.     
  122.     
  123.     mobj = fMenuList.GetFirst();
  124.     while(mobj != NULL)
  125.     {
  126.         HandleWindowActivation(mobj->fMenuObject,window,isBeingActivated);
  127.         mobj = mobj->next;
  128.     }
  129. }
  130.  
  131.  
  132.  
  133.  
  134.  
  135. Menu *BaseMenuManager::DoGetMenu(UInt32 menuID)
  136. {
  137.     return HandleGetMenu(menuID);
  138. }
  139.  
  140.  
  141.  
  142.  
  143.  
  144. void BaseMenuManager::HandleAddMenu(Menu *menu)
  145. {
  146.     BaseMenuObject    *obj;
  147.     
  148.     
  149.     obj = new BaseMenuObject;
  150.     if (obj != NULL)
  151.     {
  152.         obj->fMenuID = menu->fMenu[0]->menuID;
  153.         obj->fMenuObject = menu;
  154.         fMenuList.Append(obj);
  155.         ::InsertMenu(menu->fMenu,0);
  156.     }
  157. }
  158.  
  159.  
  160.  
  161.  
  162.  
  163. void BaseMenuManager::HandleMenuUpdate(Menu *menu)
  164. {
  165.     menu->DoUpdate();
  166. }
  167.  
  168.  
  169.  
  170.  
  171.  
  172. void BaseMenuManager::HandleSelect(Menu *menu,UInt32 item)
  173. {
  174.     menu->DoSelect(item);
  175. }
  176.  
  177.  
  178.  
  179.  
  180.  
  181. void BaseMenuManager::HandleWindowNotice(Menu *menu,Window *window,Boolean isBeingAdded)
  182. {
  183.     menu->DoWindowNotice(window,isBeingAdded);
  184. }
  185.  
  186.  
  187.  
  188.  
  189.  
  190. void BaseMenuManager::HandleWindowActivation(Menu *menu,Window *window,Boolean isBeingActivated)
  191. {
  192.     menu->DoWindowActivation(window,isBeingActivated);
  193. }
  194.  
  195.  
  196.  
  197.  
  198.  
  199. Menu *BaseMenuManager::HandleGetMenu(UInt32 menuID)
  200. {
  201.     BaseMenuObject    *obj;
  202.     
  203.     
  204.     obj = fMenuList.GetFirst();
  205.     while(obj && (obj->fMenuID != menuID))
  206.         obj = obj->next;
  207.     
  208.     return obj ? obj->fMenuObject : NULL;
  209. }
  210.  
  211.  
  212.  
  213.  
  214.  
  215. BaseMenu::BaseMenu(UInt32 menuID)
  216. {
  217.     fMenu = ::GetMenu(menuID);
  218.     if (fMenu != NULL)
  219.     {
  220.         fFlags = 0;
  221.         gMenuManager->DoAddMenu(this);
  222.     }
  223. }
  224.  
  225.  
  226.  
  227.  
  228.  
  229. void BaseMenu::DoUpdate(void)
  230. {
  231.     HandleUpdate();
  232. }
  233.  
  234.  
  235.  
  236.  
  237.  
  238. void BaseMenu::DoSelect(UInt32 item)
  239. {
  240.     HandleSelect(item);
  241. }
  242.  
  243.  
  244.  
  245.  
  246.  
  247. Boolean BaseMenu::DoSetDisableState(Boolean isBeingDisabled)
  248. {
  249.     if (isBeingDisabled)
  250.     {
  251.         if (!(fFlags & kDisabled))
  252.         {
  253.             fFlags |= kDisabled;
  254.             HandleSetDisableState(isBeingDisabled);
  255.             return true;
  256.         }
  257.     }
  258.     else
  259.     {
  260.         if (fFlags & kDisabled)
  261.         {
  262.             fFlags &= ~kDisabled;
  263.             HandleSetDisableState(isBeingDisabled);
  264.             return true;
  265.         }
  266.     }
  267.     
  268.     return false;
  269. }
  270.  
  271.  
  272.  
  273.  
  274.  
  275. void BaseMenu::DoWindowNotice(Window *window,Boolean isBeingAdded)
  276. {
  277.     HandleWindowNotice(window,isBeingAdded);
  278. }
  279.  
  280.  
  281.  
  282.  
  283.  
  284. void BaseMenu::DoWindowActivation(Window *window,Boolean isBeingActivated)
  285. {
  286.     HandleWindowActivation(window,isBeingActivated);
  287. }
  288.  
  289.  
  290.  
  291.  
  292.  
  293. void BaseMenu::HandleUpdate(void)
  294. {
  295.     
  296. }
  297.  
  298.  
  299.  
  300.  
  301.  
  302. void BaseMenu::HandleSelect(UInt32 item)
  303. {
  304.     
  305. }
  306.  
  307.  
  308.  
  309.  
  310.  
  311. void BaseMenu::HandleSetDisableState(Boolean isBeingDisabled)
  312. {
  313.     if (isBeingDisabled)
  314.         DisableItem(fMenu,0);
  315.     else
  316.         EnableItem(fMenu,0);
  317. }
  318.  
  319.  
  320.  
  321.  
  322.  
  323. void BaseMenu::HandleWindowNotice(Window *window,Boolean isBeingAdded)
  324. {
  325.     
  326. }
  327.  
  328.  
  329.  
  330.  
  331.  
  332. void BaseMenu::HandleWindowActivation(Window *window,Boolean isBeingActivated)
  333. {
  334.     
  335. }
  336.  
  337.  
  338.  
  339.  
  340.  
  341. AppleMenu::AppleMenu(void) : BaseMenu(256)
  342. {
  343.     AppendResMenu(fMenu,'DRVR');
  344. }
  345.  
  346.  
  347.  
  348.  
  349.  
  350. void AppleMenu::HandleSelect(UInt32 item)
  351. {
  352.     QDContext    context;
  353.     Str255        name;
  354.     
  355.     
  356.     switch(item)
  357.     {
  358.         case 1:
  359.             ShowAboutBox();
  360.             break;
  361.         
  362.         default:
  363.             GetMenuItemText(fMenu,item,name);
  364.             OpenDeskAcc(name);
  365.             break;
  366.     }
  367. }
  368.  
  369.  
  370.  
  371.  
  372.  
  373. void AppleMenu::HandleSetDisableState(Boolean isBeingDisabled)
  374. {
  375.     if (isBeingDisabled)
  376.         DisableItem(fMenu,1);
  377.     else
  378.         EnableItem(fMenu,1);
  379. }
  380.  
  381.  
  382.  
  383.  
  384.  
  385. void AppleMenu::ShowAboutBox(void)
  386. {
  387.     Str31        vnum,vers;
  388.     Str255        name;
  389.     OSStatus    err;
  390.     
  391.     
  392.     // Get app name from Apple menu.
  393.     GetMenuItemText(fMenu,1,name);
  394.     while((name[0] > 0) && !isspace(name[1]))
  395.         memmove(&name[1],&name[2],--name[0]);
  396.     while((name[0] > 0) && isspace(name[1]))
  397.         memmove(&name[1],&name[2],--name[0]);
  398.     while((name[0] > 0) && ((char)name[name[0]] == (char)'…'))
  399.         name[0] -= 1;
  400.     
  401.     // Get version from vers resource.
  402.     err = GetNumVersionPString(vnum);
  403.     if (err == noErr)
  404.     {
  405.         pstrcpy(vers,"\pversion: ");
  406.         pstrcat(vers,vnum);
  407.     }
  408.     else
  409.         vers[0] = 0;
  410.     
  411.     PostNotice(kAlertNoteAlert,name,vers);
  412. }
  413.  
  414.  
  415.  
  416.  
  417.  
  418. FileMenu::FileMenu(void) : BaseMenu(257)
  419. {
  420.     
  421. }
  422.  
  423.  
  424.  
  425.  
  426.  
  427. void FileMenu::HandleSelect(UInt32 item)
  428. {
  429.     switch(item)
  430.     {
  431.         default:
  432.             InitiateAppQuit();
  433.             break;
  434.     }
  435. }
  436.  
  437.  
  438.  
  439.  
  440.  
  441. EditMenu::EditMenu(void) : BaseMenu(258)
  442. {
  443.     
  444. }
  445.  
  446.  
  447.  
  448.  
  449.  
  450. void EditMenu::HandleSelect(UInt32 item)
  451. {
  452.     Window    *win;
  453.     
  454.     
  455.     win = gWindowManager->DoGetFrontWindow();
  456.     if (win != NULL)
  457.     {
  458.         switch(item)
  459.         {
  460.             case 1:
  461.                 win->DoSetParam('undo',0);
  462.                 break;
  463.             
  464.             case 3:
  465.                 win->DoSetParam('cut ',0);
  466.                 break;
  467.             
  468.             case 4:
  469.                 win->DoSetParam('copy',0);
  470.                 break;
  471.             
  472.             case 5:
  473.                 win->DoSetParam('past',0);
  474.                 break;
  475.             
  476.             case 6:
  477.                 win->DoSetParam('clea',0);
  478.                 break;
  479.         }
  480.     }
  481. }
  482.